package com.gupaoedu.vip.spring.v2.servlet;




import com.gupaoedu.vip.spring.annotation.*;

import javax.servlet.ServletConfig;
import javax.servlet.ServletException;
import javax.servlet.http.HttpServlet;
import javax.servlet.http.HttpServletRequest;
import javax.servlet.http.HttpServletResponse;
import java.io.File;
import java.io.IOException;
import java.io.InputStream;
import java.lang.annotation.Annotation;
import java.lang.reflect.Field;
import java.lang.reflect.Method;
import java.net.URL;
import java.util.*;
/**
 * @Author: JLL
 * @Date: 2019/4/16 22:25
 */
public class DispatcherServlet extends HttpServlet{

    //保存application.properties中的内容
    //初始化一个全局变量，这里用Properties来代替xml文件，相当于文件转到内存了
    private Properties contextConfig = new Properties();
    //保存扫描到的所有类名
    private List<String> classNames = new ArrayList<>();
    //这就是IOC容器。。为了简化程序，这里暂时不考虑ConcurrentHashMap，主要先关注设计思想
    private Map<String,Object> ioc = new HashMap<>();
    //保存url和Method的对应关系
    private Map<String,Method> handlerMapping = new HashMap<>();


    @Override
    protected void doGet(HttpServletRequest req, HttpServletResponse resp) throws ServletException, IOException {
        this.doPost(req,resp);
    }

    /**
     * 运行阶段
     * @param req
     * @param resp
     * @throws ServletException
     * @throws IOException
     */
    @Override
    protected void doPost(HttpServletRequest req, HttpServletResponse resp) throws ServletException, IOException {

        //6、调用
        try {
            doDispatch(req,resp);
        } catch (Exception e) {
            e.printStackTrace();
            //把异常的堆栈信息也打出去
            resp.getWriter().write("500 exception ,detail: " + Arrays.toString(e.getStackTrace()));
        }
    }

    /**
     *  初始化之后，开始了第三阶段：运行阶段
     * @param req
     * @param resp
     */
    private void doDispatch(HttpServletRequest req, HttpServletResponse resp) throws  Exception{

        String url = req.getRequestURI();
        //处理成相对路径，不管中间输了多少/，都把它替换成一个/
        String contextPath = req.getContextPath();
        url = url.replaceAll(contextPath,"").replaceAll("/+","/");

        if(!this.handlerMapping.containsKey(url)){
            resp.getWriter().write("404 Not Found!!!");
            //不执行了
            return;
        }

        Method method = this.handlerMapping.get(url);
        //从request中拿到url传过来的参数（实参）
        Map<String,String[]> params = req.getParameterMap();


        //获取方法的形参列表
        Class<?> [] parameterTypes = method.getParameterTypes();

        //放实参的。（实际接收到的参数）
        //搞一个数组，等下反射的时候作为参数传进去     这就是实参，和形参的长度是一样的
        Object [] paramValues = new Object[parameterTypes.length];

        /**
         *  循环形参，把形参和实参 对应起来  （springmvc当中，这就是解析参数，很重要的一部）
         */
        for (int i = 0; i < parameterTypes.length; i ++) {
            Class parameterType = parameterTypes[i];
            //不能用instanceof，parameterType 它不是实参，而是形参
            if(parameterType == HttpServletRequest.class){
                paramValues[i] = req;
                continue; //为啥continue？ （continue就是跳出for循环）加了一次就不再加进来了。因为HttpServletRequest的形参，只有可能有一个
            }else if(parameterType == HttpServletResponse.class){
                paramValues[i] = resp;
                continue;

                // 比如string name=Tom&name=Jack 还有string address=xili&adress=qianhai、、if第一次进去处理的是name、第二次进去处理的是address
            }else if(parameterType == String.class){ //暂时只考虑string类型的参数。string类型的有可能有多个参数
                //把方法上的注解拿到，得到的是一个二维数组  （为什么是二维数组，因为一个参数有可能有多个注解）
                //遍历j < pa.length。就是便利一维数组。 这里就是遍历每一个注解。。
                Annotation[][] pa = method.getParameterAnnotations();
                for (int j = 0; j < pa.length; j++) {
                    for (Annotation a : pa[j]) {
                        //我们现在要解析的只是GPRequestParam  开始遍历name和address
                        if(a instanceof  GPRequestParam){
                            //拿到参数的名称 name。一会儿去和url匹配 http://localhost/demo/query?name=Tom
                            String paramName  = ((GPRequestParam)a).value(); //这个就是@GPRequestParam("name")里面的name

                            //从req获得的实参列表中 去找对应的key
                            if(params.containsKey(paramName ) ){
                                //然后就开始循环处理，因为string类型的参数可能有好几个。。params的key是name，value是多个值
                                for (Map.Entry<String,String[]> param : params.entrySet()){
                                    //拿到key对应的值，就是tom，jack，这个值是一对多的关系。，，
                                    //一个key对应一个数组
                                    //举个例子： http://localhost/demo/query?name=Tom&name=Mic&name=James
                                    System.out.println(Arrays.toString(param.getValue()));

                                    //而对方接收的是string类型，所以就把数据统一处理成string
                                    String value = Arrays.toString(param.getValue())
                                            //把数组[] 去掉。。
                                            .replaceAll("\\[|\\]","")
                                            //把空格处理成逗号
                                            .replaceAll("\\s",",");

                                    //类型的强制转换
                                    paramValues[i] = value;
                                }
                            }
                        }


                    }
                }

                /**
                 * 举例解释： 比如现在输入 http://localhost/demo/query?name=Tom
                 * 那么 params 是：  key="name"  value=["Tom"]
                 * GPRequestParam requestParam = (GPRequestParam)parameterType.getAnnotation(GPRequestParam.class);
                 * requestParam 的value就是name
                 * 现在params的key是包含requestParam的
                 *
                 * 这里只是一个简化的版本
                 * 这里正确的写法和注释 参见v3的GPDispatcherServlet类的putParamIndexMapping -》 Handler-》initHandlerMapping-》
                 *
                 */

                /*GPRequestParam requestParam = (GPRequestParam)parameterType.getAnnotation(GPRequestParam.class);
                //例子就是：实参的map有包含有name。。。
                if(params.containsKey(requestParam.value())) {
                    //然后就开始循环处理，因为string类型的参数可能有好几个。。params的key是name，value是多个值
                    for (Map.Entry<String,String[]> param : params.entrySet()){
                        System.out.println(Arrays.toString(param.getValue()));
                        String value = Arrays.toString(param.getValue())
                                //把数组[] 去掉。。
                                .replaceAll("\\[|\\]","")
                                //把空格处理成逗号
                                .replaceAll("\\s",",");
                        paramValues[i] = value;
                    }
                }*/
            }
        }

        //投机取巧的方式 （这里是简易版本，不考虑beanName是自定义的情况）
        //通过反射拿到method所在class，拿到class之后还是拿到class的名称（这个在之前的反射学习中，没写过，这里又学到一新的）
        //再调用toLowerFirstCase获得beanName
        String beanName  = toLowerFirstCase(method.getDeclaringClass().getSimpleName());
        method.invoke(ioc.get(beanName),paramValues);

        //暂时写死调试
        /*Map<String,String[]> paramsTest = req.getParameterMap();

        method.invoke(ioc.get(beanName),new Object[]{req,resp,paramsTest.get("name")[0]});*/

    }


    //url传过来的参数都是String类型的，HTTP是基于字符串协议
    //只需要把String转换为任意类型就好
    private Object convert(Class<?> type,String value){
        //如果是int
        if(Integer.class == type){
            return Integer.valueOf(value);
        }
        else if(Double.class == type){
            return Double.valueOf(value);
        }
        //如果还有double或者其他类型，继续加if
        //这时候，我们应该想到策略模式了
        //在这里暂时不实现，希望小伙伴自己来实现
        return value;
    }

    /**
     * 初始化阶段
     * @param config
     * @throws ServletException
     */
    @Override
    public void init(ServletConfig config) throws ServletException {
        //1、加载配置文件
        doLoadConfig(config.getInitParameter("contextConfigLocation"));
        //2、扫描相关的类
        doScanner(contextConfig.getProperty("scanPackage"));
        //3、初始化扫描到的类，并将它们放到IOC容器中
        doInstance();
        //4、完成依赖注入
        doAutowired();
        //5、初始化HandlerMapping
        doHandlerMapping();

        System.out.println("GP Spring Framework is init.. 然后开始调用");

    }

    /**
     *  初始化url和Method的一对一对应关系
     */
    private void doHandlerMapping() {
        if(ioc.isEmpty()){return ;}

        for (Map.Entry<String, Object> entry : ioc.entrySet()) {
            Class<?> clazz = entry.getValue().getClass();
            //没有GPController，直接continue
            if(!clazz.isAnnotationPresent(GPController.class)){continue;}


            //保存写在类上面的@GPRequestMapping("/demo")
            String baseUrl = "";
            if(clazz.isAnnotationPresent(GPRequestMapping.class)){
                GPRequestMapping requestMapping = clazz.getAnnotation(GPRequestMapping.class);
                baseUrl = requestMapping.value();
            }

            //默认获取所有的public方法
            for (Method method : clazz.getMethods()) {
                if(!method.isAnnotationPresent(GPRequestMapping.class)){continue;}

                GPRequestMapping requestMapping = method.getAnnotation(GPRequestMapping.class);
                //优化
                // //demo///query   这里做一个通用的适配，如果用户类和方法上都输入了/  那就用正则表达式，把多个/ 合并成一个/
                String url = ("/" + baseUrl + "/" + requestMapping.value())
                        .replaceAll("/+","/");
                handlerMapping.put(url,method);
                System.out.println("Mapped :" + url + "," + method);

            }


        }

    }

    private void doAutowired() {
        if(ioc.isEmpty()){return ;}

        for (Map.Entry<String, Object> entry : ioc.entrySet()) {
            //Declared 所有的，特定的 字段，包括private/protected/default
            //正常来说，普通的OOP编程只能拿到public的属性
            Field[] fields = entry.getValue().getClass().getDeclaredFields();
            for (Field field : fields) {
                if(!field.isAnnotationPresent(GPAutowired.class)){continue;}
                GPAutowired autowired = field.getAnnotation(GPAutowired.class);

                //如果用户没有自定义beanName，默认就根据类型注入(因为doInstance里面的第三点：投机取巧的方式)
                //这个地方省去了对类名首字母小写的情况的判断，这个作为课后作业
                //小伙伴们自己去完善
                String beanName = autowired.value().trim();
                if("".equals(beanName)){
                    //获得接口的类型，作为key（应该是接口的全类名），待会拿这个key到ioc容器中去取值（这个key就是投机取巧里面放的key？？这里待验证，我猜测是的）
                    beanName = field.getType().getName();
                }

                //如果是public以外的修饰符，只要加了@Autowired注解，都要强制赋值
                //反射中叫做暴力访问， 强吻
                field.setAccessible(true);

                try {
                    //用反射机制，动态给字段赋值
                    field.set(entry.getValue(),ioc.get(beanName));
                } catch (IllegalAccessException e) {
                    e.printStackTrace();
                }
            }
        }
    }

    /**
     * 初始化
     */
    private void doInstance() {
        //初始化，为DI做准备
        if(classNames.isEmpty()){return; } //包下没有类，不用初始化
        for (String className : classNames) {
            try {
                Class<?> clazz  = Class.forName(className);

                //什么样的类才需要初始化呢？
                // 加了注解的类才初始化，而接口是无法初始化的，只能初始化它的实现类 。那怎么判断注解呢？
                //为了简化代码逻辑，主要体会设计思想，只举例 @GPController和@GPService,
                // @Componment...就不一一举例了
                if(clazz.isAnnotationPresent(GPController.class) ) {
                    Object instance = clazz.newInstance();
                    //Key 应该是ClassName的首字母小写，spring的bean默认是类名首字母小写
                    String beanName = toLowerFirstCase(clazz.getSimpleName());
                    ioc.put(beanName,instance);
                }else if(clazz.isAnnotationPresent(GPService.class)){
                    //1、自定义的beanName
                    GPService service = clazz.getAnnotation(GPService.class);
                    String beanName = service.value();
                    //2、默认类名首字母小写
                    if("".equals(beanName.trim())){
                        beanName = toLowerFirstCase(clazz.getSimpleName());
                    }
                    Object instance = clazz.newInstance();
                    ioc.put(beanName,instance);
                    //3、根据类型（类型就是接口名字啊）自动赋值,投机取巧的方式
                    //  先拿到实现类的接口 clazz.getInterfaces() 这里就是 IDemoService
                    for (Class<?> i : clazz.getInterfaces()) {
                        //接口会有多个实现类，多个实现类有可能取名成相同的key，这个时候如果key已存在，那么报错。spring直接启动报错
                        if(ioc.containsKey(i.getName())){
                            throw new Exception("The “" + i.getName() + "” is exists!!");
                        }
                        //把接口的全类名 作为它的key
                        //把接口的类型直接当成key了
                        //这里的key是com.gupaoedu.vip.demo.service.IDemoService 全类名
                        ioc.put(i.getName(),instance);
                    }
                }else{
                    continue;
                }
            } catch (Exception e) {
                e.printStackTrace();
            }
        }
    }

    //如果类名本身是小写字母，确实会出问题
    //但是我要说明的是：这个方法是我自己用，private的
    //传值也是自己传，类也都遵循了驼峰命名法
    //默认传入的值，是不存在首字母小写的情况，也不可能出现非字母的情况。所以没事

    //为了简化程序逻辑，就不做其他判断了，大家了解就OK
    //其实用写注释的时间都能够把逻辑写完了
    private String toLowerFirstCase(String simpleName) {
        char [] chars = simpleName.toCharArray();
        //之所以加32，是因为大小写字母的ASCII码相差32，
        // 而且大写字母的ASCII码要小于小写字母的ASCII码
        //在Java中，对char做算学运算，实际上就是对ASCII码做算学运算
        chars[0] += 32;
        return String.valueOf(chars);
    }


    /**
     * 参数是要扫描的包
     * 扫描出包下 所有的类
     * @param scanPackage
     */
    private void doScanner(String scanPackage) {
        //扫出来是com.gupaoedu.vip.demo，但是我们需要存储的是包路径，要转换为文件路径，才行。
        //用url接收，这个url在这里就认为是一个classpath
        URL url  = this.getClass().getClassLoader().getResource("/" + scanPackage.replaceAll("\\.","/"));
        //有了classpath，再封装成File
        File classpath = new File(url.getFile());
        for (File file : classpath.listFiles()) {
            //classpath下面可能是文件，也有可能是文件夹，文件夹的话就递归。
            if(file.isDirectory()){
                doScanner(scanPackage + "." + file.getName());
            }else {
                //如果不是class，就continue。 不要别的文件，只要class文件
                if(!file.getName().endsWith(".class")){continue;}
                //这样就得到所有class文件的完整的类名
                String className = scanPackage + "." + file.getName().replaceAll(".class","");
                classNames.add(className);
            }



        }


    }

    /**
     * 加载servlet配置文件web.xml springMVC需要的配置文件
     *
     * contextConfigLocation是一个路径，把它找到先
     */
    private void doLoadConfig(String contextConfigLocation) {
        //直接从类路径下找到spring主配置文件
        //并且将其读取出来放到Properties对象中
        //相当于把scanPackage=com.gupaoedu.vip.demo 从文件中保存到了内存中
        InputStream fis = this.getClass().getClassLoader().getResourceAsStream(contextConfigLocation);
        try {
            contextConfig.load(fis);
        } catch (IOException e) {
            e.printStackTrace();
        }finally {
            if (fis != null) {
                try {
                    fis.close();
                } catch (IOException e) {
                    e.printStackTrace();
                }
            }
        }


    }

}
